//package com.panfeng.xcloud.scheduler.service.impl;
//
//import com.alibaba.fastjson.JSON;
//import com.alibaba.fastjson.JSONArray;
//import com.alibaba.fastjson.JSONObject;
//import com.binance.client.model.enums.CandlestickInterval;
//import com.panfeng.xcloud.boss.provider.dto.request.OperateBotReqDTO;
//import com.panfeng.xcloud.boss.provider.dto.request.QuantBotDetailDTO;
//import com.panfeng.xcloud.common.core.candle.Entry;
//import com.panfeng.xcloud.common.core.configuration.DataDictionaryConfig;
//import com.panfeng.xcloud.common.core.enums.*;
//import com.panfeng.xcloud.common.core.exceptions.BaseBizException;
//import com.panfeng.xcloud.common.core.utils.KeyContactUtil;
//import com.panfeng.xcloud.common.core.web.vo.OrderDetailResponseVO;
//import com.panfeng.xcloud.common.core.web.vo.TradeResponseVO;
//import com.panfeng.xcloud.dao.assets.entity.UserBot;
//import com.panfeng.xcloud.scheduler.dao.mapper.CoinListMapperExt;
//import com.panfeng.xcloud.scheduler.dao.mapper.UserBotMapperExt;
//import com.panfeng.xcloud.scheduler.dao.mapper.UserExchangePwdMapperExt;
//import com.panfeng.xcloud.scheduler.service.*;
//import lombok.extern.slf4j.Slf4j;
//import org.apache.commons.lang3.StringUtils;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.beans.factory.annotation.Value;
//import org.springframework.data.redis.core.RedisTemplate;
//import org.springframework.data.redis.core.StringRedisTemplate;
//import org.springframework.stereotype.Service;
//
//import java.math.BigDecimal;
//import java.util.Iterator;
//import java.util.List;
//
//@Slf4j
//@Service
//public class QuantBotServiceImpl implements IQuantBotService {
//
//    @Autowired
//    private RedisTemplate redisTemplate;
//
//    @Autowired
//    private StringRedisTemplate stringRedisTemplate;
//
//    @Autowired
//    private DataDictionaryConfig dataDictionaryConfig;
//
//    @Autowired
//    private UserExchangePwdMapperExt userExchangePwdMapperExt;
//
//    @Autowired
//    private UserBotMapperExt userBotMapperExt;
//
//    @Autowired
//    private CoinListMapperExt coinListMapperExt;
//
//    @Autowired
//    private IFeignService feignService;
//
//    @Autowired
//    private IRiskManagerService iRiskManagerService;
//
//    @Autowired
//    private ICalculatePriceService iCalculatePriceService;
//
//    @Autowired
//    private IOffSetService iOffSetService;
//
//    @Value("${xdcloud.des3.secret-key}")
//    private String secrectKey;
//
//    @Override
//    public void runQuantBot() {
//        //找到所有正在运行中的机器人
//        List<UserBot> userBots = userBotMapperExt.selectBots(Integer.valueOf(UserBotStatusTypeEnum.ACTIVE.getCode()), null);
//        log.info("当前执行机器人数量:{}", userBots.size());
//        Iterator<UserBot> iterator = userBots.iterator();
//        while (iterator.hasNext()) {
//            UserBot userBot = iterator.next();
//            String userBotKey = KeyContactUtil.getUserBotKey(userBot.getExchangeType(), userBot.getDirection(), userBot.getLeverRate(), userBot.getDestinationCoin(), userBot.getSourceCoin(), userBot.getUserId());
//            String userId = userBot.getUserId();
//            String contractCode = KeyContactUtil.getContractCode(userBot.getExchangeType(), userBot.getDestinationCoin(), userBot.getSourceCoin());
//            QuantBotDetailDTO quantBotDetailDTO = JSONObject.parseObject(stringRedisTemplate.opsForValue().get(userBotKey), QuantBotDetailDTO.class);
//            try {
//                if (null != quantBotDetailDTO && quantBotDetailDTO.getStatus().equals(UserBotStatusTypeEnum.ACTIVE.getCode())) {
//                    Long t1 = System.currentTimeMillis();
//                    robotExecute(quantBotDetailDTO, userBotKey);
//                    Long t2 = System.currentTimeMillis();
//                    log.info("当前机器人执行用户:{},币对:{},多空方向:{},杠杆倍数:{},该次执行耗时:{}", userId, contractCode, userBot.getDirection(), userBot.getLeverRate(), t2 - t1);
//                }
//            } catch (Exception e) {
//                log.error("用户:{}的机器人执行异常,币对:{},多空方向:{},杠杆倍数:{},异常信息:{}", userId, contractCode, userBot.getDirection(), userBot.getLeverRate(), e.getMessage(), e);
//
//                //需要清除机器人的异常
//                needDeleteBotException(userBotKey, quantBotDetailDTO, e);
//
//                //无需发提醒邮件的异常
//                boolean noNeedSendEmail = noNeedSendEmailException(e);
//                if (!noNeedSendEmail) {
//                    feignService.sendEmail("   用户id:" + userId
//                            + "   方向:" + userBot.getDirection()
//                            + "   倍数:" + userBot.getLeverRate()
//                            + "   交易对:" + contractCode
//                            + "   异常信息:" + com.panfeng.xcloud.common.core.utils.StringUtils.printStackTraceToString(e));
//                }
//                continue;
//            }
//        }
//    }
//
//    private void robotExecute(QuantBotDetailDTO quantBotDetailDTO, String userBotKey) throws Exception {
//        //获取K线数据,并且计算KDJ
//        JSONObject candleStick = feignService.getCandleStick(Integer.valueOf(quantBotDetailDTO.getExchangeType()), quantBotDetailDTO.getUserId(),
//                quantBotDetailDTO.getDestinationCoin(), quantBotDetailDTO.getSourceCoin(), CandlestickInterval.ONE_MINUTE, null, null, 26);
//        List[] kdjs = iCalculatePriceService.calculateKdj(candleStick);
//        List<Entry> kValue = kdjs[0];
//        List<Entry> dValue = kdjs[1];
//        List<Entry> jValue = kdjs[2];
//
//        //均价为0则走择机开仓逻辑,均价大于0则走已经开仓的正常机器人逻辑
//        if (new BigDecimal(quantBotDetailDTO.getAvgPrice()).compareTo(BigDecimal.ZERO) == 0) {
//            quantBotDetailDTO = robotOpenPositionExecute(quantBotDetailDTO, kValue, dValue, jValue, userBotKey, candleStick);
//        } else if (new BigDecimal(quantBotDetailDTO.getAvgPrice()).compareTo(BigDecimal.ZERO) > 0) {
//            quantBotDetailDTO = robotRunningExecute(quantBotDetailDTO, kValue, dValue, jValue, userBotKey);
//        } else {
//            throw new BaseBizException(ResponseStatusEnum.AVGPRICE_ERROR);
//        }
//
//        //更新交易对详情
//        stringRedisTemplate.opsForValue().set(userBotKey, JSON.toJSONString(quantBotDetailDTO));
//    }
//
//    private QuantBotDetailDTO robotOpenPositionExecute(QuantBotDetailDTO quantBotDetailDTO, List<Entry> kValue, List<Entry> dValue, List<Entry> jValue,
//                                                       String userBotKey, JSONObject candleStick) throws Exception {
//        if (quantBotDetailDTO.getDirection().equals(PositionSideTypeEnum.BUY.getCode())) {
//            //多单情况下，持仓均价为0，第一根J<K<D,第二根J>K>D则开仓
//            if ((jValue.get(1).getY() < kValue.get(1).getY() && kValue.get(1).getY() < dValue.get(1).getY()) &&
//                    (jValue.get(2).getY() > kValue.get(2).getY() && kValue.get(2).getY() > dValue.get(2).getY())) {
//                quantBotDetailDTO = openPosition(quantBotDetailDTO, userBotKey);
//            }
//        } else if (quantBotDetailDTO.getDirection().equals(PositionSideTypeEnum.SELL.getCode())) {
//            //空单情况下，持仓均价为0，第一根J>K>D，第二根J<K<D则开仓
//            if ((jValue.get(1).getY() > kValue.get(1).getY() && kValue.get(1).getY() > dValue.get(1).getY()) &&
//                    (jValue.get(2).getY() < kValue.get(2).getY() && kValue.get(2).getY() < dValue.get(2).getY())) {
//                quantBotDetailDTO = openPosition(quantBotDetailDTO, userBotKey);
//            }
//        } else {
//            throw new BaseBizException(ResponseStatusEnum.ROBOT_DIRECTION_NOT_EXIST);
//        }
//
//        //计算最新价格
//        JSONArray candlesticks = candleStick.getJSONArray("candlesticks");
//        JSONObject obj = (JSONObject) (candlesticks.get(candlesticks.size() - 1));
//        float close = obj.getFloatValue("close");
//
//        quantBotDetailDTO.setCurrentBidPrice(String.valueOf(close));
//
//        return quantBotDetailDTO;
//    }
//
//    private QuantBotDetailDTO robotRunningExecute(QuantBotDetailDTO quantBotDetailDTO, List<Entry> kValue, List<Entry> dValue, List<Entry> jValue, String userBotKey) throws Exception {
//        //获取当前最新的价格深度,并且得到经过计算成交深度与盘口价格的价格数组，0为买价格，1为卖价格
//        JSONObject depth = feignService.getMarketPriceDepth(Integer.valueOf(quantBotDetailDTO.getExchangeType()), quantBotDetailDTO.getUserId(),
//                quantBotDetailDTO.getDestinationCoin(), quantBotDetailDTO.getSourceCoin());
//        BigDecimal[] priceArray = iCalculatePriceService.calculatePrice(depth, quantBotDetailDTO);
//
//        log.info("当前买价格:{}", priceArray[0]);
//        log.info("当前卖价格:{}", priceArray[1]);
//
//        //当前涨幅
//        BigDecimal bidRise = null;
//        BigDecimal askRise = null;
//
//        //当前均价
//        BigDecimal avgPrice = new BigDecimal(quantBotDetailDTO.getAvgPrice());
//
//        if (quantBotDetailDTO.getDirection().equals(PositionSideTypeEnum.BUY.getCode())) {
//            //如果是多单,那么上涨是止盈,下跌是补仓
//            bidRise = (priceArray[0].subtract(avgPrice)).divide(avgPrice, 6, BigDecimal.ROUND_DOWN);
//            askRise = (priceArray[1].subtract(avgPrice)).divide(avgPrice, 6, BigDecimal.ROUND_DOWN);
//        } else if (quantBotDetailDTO.getDirection().equals(PositionSideTypeEnum.SELL.getCode())) {
//            //如果是空单,那么上涨是补仓,下跌是止盈
//            bidRise = (avgPrice.subtract(priceArray[0])).divide(avgPrice, 6, BigDecimal.ROUND_DOWN);
//            askRise = (avgPrice.subtract(priceArray[1])).divide(avgPrice, 6, BigDecimal.ROUND_DOWN);
//        } else {
//            throw new BaseBizException(ResponseStatusEnum.ROBOT_DIRECTION_NOT_EXIST);
//        }
//
//        quantBotDetailDTO.setBidRise(bidRise.toString());
//        quantBotDetailDTO.setAskRise(askRise.toString());
//
//        log.info("当前持仓金额:{}", quantBotDetailDTO.getPositionAmount());
//        log.info("当前持仓数量:{}", quantBotDetailDTO.getPositionNum());
//        log.info("当前持仓均价:{}", quantBotDetailDTO.getAvgPrice());
//        log.info("当前买盘价格:{}", priceArray[0]);
//        log.info("当前卖盘价格:{}", priceArray[1]);
//        log.info("当前买盘涨幅:{}%", bidRise.multiply(new BigDecimal("100")));
//        log.info("当前卖盘涨幅:{}%", askRise.multiply(new BigDecimal("100")));
//
//        //风险控制系统,执行风险控制逻辑
//        quantBotDetailDTO = iRiskManagerService.manageRisk(quantBotDetailDTO, userBotKey, priceArray[0], priceArray[1]);
//
//        //未锁仓的情况下才能去做判断
//        if (!quantBotDetailDTO.getLock()) {
//            if (quantBotDetailDTO.getDirection().equals(PositionSideTypeEnum.BUY.getCode())) {
//                //多单情况下，持仓均价大于0，达到了下述条件就加仓
//                if ((Integer.valueOf(quantBotDetailDTO.getCurrentAntiAddCount()) < Integer.valueOf(quantBotDetailDTO.getAntiAddCount())) &&
//                        (askRise.compareTo(getAntiAddPositionRatio(quantBotDetailDTO)) >= 0)) {
//                    quantBotDetailDTO = toExecuteAntiDown(quantBotDetailDTO, askRise, userBotKey);
//
//                    //多单情况下，持仓均价大于0，达到了下述条件就止盈
//                } else if ((Integer.valueOf(quantBotDetailDTO.getCurrentAntiAddCount()) >= Integer.valueOf(quantBotDetailDTO.getAntiAddCount())) &&
//                        (bidRise.compareTo(new BigDecimal(quantBotDetailDTO.getAntiStopProfitRatio())) >= 0)) {
//                    quantBotDetailDTO = toExecuteAntiRise(quantBotDetailDTO, bidRise, userBotKey, SystemInnerTypeEnum.ANTI_WIN_AUTO_CLEAR.code);
//
//                    //多单情况下，持仓均价大于0，第二根J<K<D就死叉清仓
//                } else if ((jValue.get(2).getY() <= kValue.get(2).getY() && kValue.get(2).getY() <= dValue.get(2).getY()) &&
//                        (jValue.get(1).getY() >= kValue.get(1).getY() && kValue.get(1).getY() >= dValue.get(1).getY())) {
//                    quantBotDetailDTO = toExecuteAntiRise(quantBotDetailDTO, bidRise, userBotKey, SystemInnerTypeEnum.KDJ_DOWN_AUTO_CLEAR.code);
//                }
//            } else if (quantBotDetailDTO.getDirection().equals(PositionSideTypeEnum.SELL.getCode())) {
//                //空单情况下，持仓均价大于0，达到了下述条件就加仓
//                if ((Integer.valueOf(quantBotDetailDTO.getCurrentAntiAddCount()) < Integer.valueOf(quantBotDetailDTO.getAntiAddCount())) &&
//                        (askRise.compareTo(getAntiAddPositionRatio(quantBotDetailDTO)) >= 0)) {
//                    quantBotDetailDTO = toExecuteAntiDown(quantBotDetailDTO, askRise, userBotKey);
//
//                    //空单情况下，持仓均价大于0，达到了下述条件就止盈
//                } else if ((Integer.valueOf(quantBotDetailDTO.getCurrentAntiAddCount()) >= Integer.valueOf(quantBotDetailDTO.getAntiAddCount())) &&
//                        (bidRise.compareTo(new BigDecimal(quantBotDetailDTO.getAntiStopProfitRatio())) >= 0)) {
//                    quantBotDetailDTO = toExecuteAntiRise(quantBotDetailDTO, bidRise, userBotKey, SystemInnerTypeEnum.ANTI_WIN_AUTO_CLEAR.code);
//
//                    //空单情况下，持仓均价大于0，第二根J>K>D就金叉清仓
//                } else if ((jValue.get(2).getY() >= kValue.get(2).getY() && kValue.get(2).getY() >= dValue.get(2).getY()) &&
//                        (jValue.get(1).getY() <= kValue.get(1).getY() && kValue.get(1).getY() <= dValue.get(1).getY())) {
//                    quantBotDetailDTO = toExecuteAntiRise(quantBotDetailDTO, bidRise, userBotKey, SystemInnerTypeEnum.KDJ_RISE_AUTO_CLEAR.code);
//                }
//            } else {
//                throw new BaseBizException(ResponseStatusEnum.ROBOT_DIRECTION_NOT_EXIST);
//            }
//        }
//
//        //更新上次市价
//        quantBotDetailDTO.setCurrentBidPrice(String.valueOf(priceArray[0]));
//
//        return quantBotDetailDTO;
//    }
//
//    public void chooseClear(QuantBotDetailDTO quantBotDetailDTO, Integer systemInnerType) throws Exception {
//        OperateBotReqDTO operateBotReqDTO = initOperateBotReqDTO(OperateTypeEnum.SELL.getCode(), quantBotDetailDTO);
//        //这里就去下单
//        feignService.chooseSendOrderHttp(operateBotReqDTO, systemInnerType);
//        log.info("执行了清仓");
//    }
//
//    private OrderDetailResponseVO chooseDouble(QuantBotDetailDTO quantBotDetailDTO, BigDecimal amount, Integer systemInnerType) throws Exception {
//        OperateBotReqDTO operateBotReqDTO = initOperateBotReqDTO(OperateTypeEnum.BUY.getCode(), quantBotDetailDTO);
//
//        BigDecimal avaliablePieces = feignService.getAvaliablePieces(Integer.valueOf(operateBotReqDTO.getExchangeType()), operateBotReqDTO);
//
//        //判断该交易对可下单数是否足够
//        if (avaliablePieces.compareTo(amount) < 0) {
//            throw new BaseBizException(ResponseStatusEnum.AVAILABLE_OPEN_AMOUNT_NOT_ENOUGH);
//        }
//
//        //获取真实下单数
//        BigDecimal realAmount = feignService.toSetOpenOrderAmount(operateBotReqDTO, amount);
//        operateBotReqDTO.setAmount(realAmount);
//
//        TradeResponseVO tradeResponseVO = feignService.chooseSendOrderHttp(operateBotReqDTO, systemInnerType);
//        OrderDetailResponseVO orderDetail = feignService.getOrderDetail(Integer.valueOf(operateBotReqDTO.getExchangeType()), operateBotReqDTO, tradeResponseVO);
//        return orderDetail;
//    }
//
//    private OperateBotReqDTO initOperateBotReqDTO(int operateType, QuantBotDetailDTO quantBotDetailDTO) {
//        OperateBotReqDTO operateBotReqDTO = new OperateBotReqDTO();
//        operateBotReqDTO.setUserId(quantBotDetailDTO.getUserId());
//        operateBotReqDTO.setOperateType(operateType);
//        operateBotReqDTO.setSourceCoin(quantBotDetailDTO.getSourceCoin());
//        operateBotReqDTO.setDestinationCoin(quantBotDetailDTO.getDestinationCoin());
//        operateBotReqDTO.setExchangeType(Integer.valueOf(quantBotDetailDTO.getExchangeType()));
//        operateBotReqDTO.setAmount(new BigDecimal(quantBotDetailDTO.getPositionPiece()));
//        operateBotReqDTO.setDirection(quantBotDetailDTO.getDirection());
//        operateBotReqDTO.setLeverRate(Integer.valueOf(quantBotDetailDTO.getLeverRate()));
//        return operateBotReqDTO;
//    }
//
//    private QuantBotDetailDTO judgeStrategy(QuantBotDetailDTO quantBotDetailDTO, String userBotKey) throws Exception {
//        //清仓后需判断是单次策略还是循环策略，如果是循环策略则直接开单，更新redis;如果是单次策略则直接更新redis并且clear机器人
//        if (quantBotDetailDTO.getStrategyType().equals(TradeStrategyTypeEnum.CIRCLE.getCode())) {
//            quantBotDetailDTO.setHighRise("0");
//            quantBotDetailDTO.setBidRise("0");
//            quantBotDetailDTO.setAskRise("0");
//            quantBotDetailDTO.setCurrentAddCount("0");
//            quantBotDetailDTO.setCurrentAntiAddCount("0");
//            //更新当前持仓数量(币计)
//            quantBotDetailDTO.setPositionNum("0");
//            //更新当前持仓数量(不确定是什么单位,该交易所下单需要什么单位就是什么单位)
//            quantBotDetailDTO.setPositionPiece("0");
//            //更新持仓金额
//            quantBotDetailDTO.setPositionAmount("0");
//            //更新持仓均价
//            quantBotDetailDTO.setAvgPrice("0");
//        } else {
//            //如果是单次策略,清除redis中的机器人
//            deleteBot(userBotKey, quantBotDetailDTO);
//
//            log.info("单次策略，机器人结束!");
//            throw new BaseBizException(ResponseStatusEnum.SINGLE_STRATEGY_ERROR);
//        }
//        return quantBotDetailDTO;
//    }
//
//    private QuantBotDetailDTO toExecuteAntiRise(QuantBotDetailDTO quantBotDetailDTO, BigDecimal bidRise, String userBotKey, Integer SystemInnerTypeEnumCode) throws Exception {
//        //调用清仓方法
//        chooseClear(quantBotDetailDTO, SystemInnerTypeEnumCode);
//
//        //清仓后需判断是单次策略还是循环策略，如果是循环策略则直接开单，更新redis；如果是单次策略则直接更新redis并且clear机器人
//        quantBotDetailDTO = judgeStrategy(quantBotDetailDTO, userBotKey);
//
//        return quantBotDetailDTO;
//    }
//
//    private QuantBotDetailDTO toExecuteAntiDown(QuantBotDetailDTO quantBotDetailDTO, BigDecimal askRise, String userBotKey) throws Exception {
//        if (quantBotDetailDTO.getLock()) {
//            log.info("当前正处于锁仓状态，不再执行逆向加仓");
//            return quantBotDetailDTO;
//        }
//        int currentAntiAddCount = Integer.valueOf(quantBotDetailDTO.getCurrentAntiAddCount());
//        int antiAddCount = Integer.valueOf(quantBotDetailDTO.getAntiAddCount());
//        if (currentAntiAddCount >= antiAddCount) {
//            log.info("[当前逆向加仓次数]到达[设定的逆向加仓次数极限],不再执行加仓");
//            return quantBotDetailDTO;
//        }
//
//        //该次逆向加仓金额
//        BigDecimal amount = iCalculatePriceService.getAntiNeedAskPieces(quantBotDetailDTO);
//
//        //逆向加仓次数加1
//        currentAntiAddCount++;
//
//        log.info("开始逆向加仓,本次加仓金额:{}", amount);
//
//        //调用倍投方法,从交易所得到真实增加的持仓数量-------------------------------------------------------------------------
//        OrderDetailResponseVO orderDetailResponseVO = chooseDouble(quantBotDetailDTO, amount, SystemInnerTypeEnum.ANTI_ADD_OPEN.code);
//        //更新当前持仓金额
//        quantBotDetailDTO.setPositionAmount(new BigDecimal(quantBotDetailDTO.getPositionAmount()).add(orderDetailResponseVO.getTradeTurnover()).toString());
//        //更新当前持仓数量(币计)
//        quantBotDetailDTO.setPositionNum(new BigDecimal(quantBotDetailDTO.getPositionNum()).add(orderDetailResponseVO.getTradeVolumeNum()).toString());
//        //更新当前持仓数量(不确定是什么单位,该交易所下单需要什么单位就是什么单位)
//        quantBotDetailDTO.setPositionPiece(new BigDecimal(quantBotDetailDTO.getPositionPiece()).add(orderDetailResponseVO.getTradeVolume()).toString());
//        //更新持仓均价
//        quantBotDetailDTO.setAvgPrice(new BigDecimal(quantBotDetailDTO.getPositionAmount()).divide(new BigDecimal(quantBotDetailDTO.getPositionNum()), 6, BigDecimal.ROUND_DOWN).toString());
//        //更新逆向加仓次数
//        quantBotDetailDTO.setCurrentAntiAddCount(String.valueOf(currentAntiAddCount));
//        //更新最近一次加仓时间
//        quantBotDetailDTO.setCurrentAddTime(String.valueOf(System.currentTimeMillis()));
//
//        log.info("交易对:{},当前持仓数量:{}", userBotKey, quantBotDetailDTO.getPositionNum());
//
//        return quantBotDetailDTO;
//    }
//
//    private QuantBotDetailDTO openPosition(QuantBotDetailDTO quantBotDetailDTO, String userBotKey) throws Exception {
//        //开仓金额
//        BigDecimal amount = new BigDecimal(quantBotDetailDTO.getInitOrderPosition());
//
//        log.info("开仓,本次开仓金额:{}", amount);
//
//        //开仓下单,从交易所得到真实增加的持仓数量-------------------------------------------------------------------------
//        OrderDetailResponseVO orderDetailResponseVO = chooseDouble(quantBotDetailDTO, amount, SystemInnerTypeEnum.OPEN_POSITION.code);
//        //更新当前持仓金额
//        quantBotDetailDTO.setPositionAmount(new BigDecimal(quantBotDetailDTO.getPositionAmount()).add(orderDetailResponseVO.getTradeTurnover()).toString());
//        //更新当前持仓数量(币计)
//        quantBotDetailDTO.setPositionNum(new BigDecimal(quantBotDetailDTO.getPositionNum()).add(orderDetailResponseVO.getTradeVolumeNum()).toString());
//        //更新当前持仓数量(不确定是什么单位,该交易所下单需要什么单位就是什么单位)
//        quantBotDetailDTO.setPositionPiece(new BigDecimal(quantBotDetailDTO.getPositionPiece()).add(orderDetailResponseVO.getTradeVolume()).toString());
//        //更新持仓均价
//        quantBotDetailDTO.setAvgPrice(new BigDecimal(quantBotDetailDTO.getPositionAmount()).divide(new BigDecimal(quantBotDetailDTO.getPositionNum()), 6, BigDecimal.ROUND_DOWN).toString());
//        //更新最近一次下单时间
//        quantBotDetailDTO.setCurrentAddTime(String.valueOf(System.currentTimeMillis()));
//
//        log.info("交易对:{},当前持仓数量:{}", userBotKey, quantBotDetailDTO.getPositionNum());
//
//        return quantBotDetailDTO;
//    }
//
//    private BigDecimal getAntiAddPositionRatio(QuantBotDetailDTO quantBotDetailDTO) {
//        BigDecimal bigDecimal;
//        int currentAntiAddCount = Integer.valueOf(quantBotDetailDTO.getCurrentAntiAddCount());
//        switch (currentAntiAddCount) {
//            case 0:
//                bigDecimal = new BigDecimal(quantBotDetailDTO.getAntiAddPositionRatio1());
//                break;
//            case 1:
//                bigDecimal = new BigDecimal(quantBotDetailDTO.getAntiAddPositionRatio2());
//                break;
//            case 2:
//                bigDecimal = new BigDecimal(quantBotDetailDTO.getAntiAddPositionRatio3());
//                break;
//            case 3:
//                bigDecimal = new BigDecimal(quantBotDetailDTO.getAntiAddPositionRatio4());
//                break;
//            case 4:
//                bigDecimal = new BigDecimal(quantBotDetailDTO.getAntiAddPositionRatio5());
//                break;
//            case 5:
//                bigDecimal = new BigDecimal(quantBotDetailDTO.getAntiAddPositionRatio6());
//                break;
//            case 6:
//                bigDecimal = new BigDecimal(quantBotDetailDTO.getAntiAddPositionRatio7());
//                break;
//            case 7:
//                bigDecimal = new BigDecimal(quantBotDetailDTO.getAntiAddPositionRatio8());
//                break;
//            case 8:
//                bigDecimal = new BigDecimal(quantBotDetailDTO.getAntiAddPositionRatio9());
//                break;
//            case 9:
//                bigDecimal = new BigDecimal(quantBotDetailDTO.getAntiAddPositionRatio10());
//                break;
//            default:
//                bigDecimal = new BigDecimal(quantBotDetailDTO.getAntiAddPositionRatio10());
//        }
//        return bigDecimal;
//    }
//
//    private void needDeleteBotException(String userBotKey, QuantBotDetailDTO quantBotDetailDTO, Exception e) {
//        if (e != null && StringUtils.isNotEmpty(e.getMessage())) {
//            if (e.getMessage().contains(ErrorCodeTypeEnum.INSUFFICIENT_CLOSE_AMOUNT_AVAILABLE.getCode())
//                    || e.getMessage().contains(ErrorCodeTypeEnum.REDUCE_ONLY_REJECTED.getMessage())) {
//                //清除机器人
//                deleteBot(userBotKey, quantBotDetailDTO);
//            }
//        }
//    }
//
//    private boolean noNeedSendEmailException(Exception e) {
//        if (e != null && StringUtils.isNotEmpty(e.getMessage())) {
//            boolean e1 = e.getMessage().contains(ResponseStatusEnum.MARKET_PRICE_REQUEST_ERROR.getMessage()) ? true : false;
//            return e1;
//        }
//        return false;
//    }
//
//    public void deleteBot(String userBotKey, QuantBotDetailDTO quantBotDetailDTO) {
//        //清除redis中机器人
//        stringRedisTemplate.delete(userBotKey);
//        //更改数据库中机器人状态为关闭
//        userBotMapperExt.updateByUserIdAndCoin(quantBotDetailDTO.getUserId(), quantBotDetailDTO.getDestinationCoin(), quantBotDetailDTO.getSourceCoin(),
//                Integer.valueOf(UserBotStatusTypeEnum.STOP.getCode()), quantBotDetailDTO.getDirection(), Integer.valueOf(quantBotDetailDTO.getLeverRate()), Integer.valueOf(quantBotDetailDTO.getExchangeType()));
//    }
//
//}
